home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 February: Technology Seed / Mac Tech Seed Feb '97.toast / OpenDoc 1.2b2c1 / TestParts / Clock / ClockPrt.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  46.7 KB  |  1,753 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        ClockPrt.cpp
  3.  
  4.     Contains:    ClockPart C++ helper object
  5.  
  6.     Owned by:    Richard Rodseth
  7.  
  8.     Copyright:    © 1995 - 1996 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <3>      10/15/96    JP        1375124 : Used Active Part prop when
  13.                                     recording.
  14.          <2>     7/16/96    EL        1295068: Do not externalize unless it is
  15.                                     dirty.
  16.         <28>    10/23/95    RR        #1291688 Added test for adding New menus
  17.         <27>    10/18/95    RR        1289153: Recover from exceptions creating
  18.                                     windows. Store fPlatformWindow pointer in
  19.                                     ClockFrame, so we can get to it even if
  20.                                     odWindow isn't successfully created.
  21.                                     Release remaining frames in ReleaseAll().
  22.         <26>    10/17/95    jpa        Recover from exceptions thrown by
  23.                                     RegisterWindowForFrame [1289153]
  24.         <25>    10/16/95    RR        #1293067 Pass shouldDispose to
  25.                                     RegisterWindow
  26.         <24>    25/09/95    NP        1979071: Check results of operator new.
  27.         <23>     9/21/95    RR        Allocate synch dialog out of temp mem
  28.         <22>     9/12/95    RR        Various activation problems. Added a
  29.                                     floating window
  30.         <21>     9/12/95    JP        1280292 & 1283803: Add Part to Send
  31.         <20>     9/11/95    NP        1272294: Messaging code cleanup.
  32.         <19>      9/1/95    RR        # 1244639 Delete window record when frame
  33.                                     is closed/removed
  34.         <18>     8/25/95    JP        1268279: Send part to frame fallout
  35.         <17>     8/15/95    RR        HandleOSEvent improvements
  36.         <16>      8/8/95    jpa        Removed DebugStrs [1265584]
  37.         <15>     7/10/95    RR        Misc. cleanup and bug fixes for shared
  38.                                     window
  39.         <14>     7/10/95    JP        Scripting cleanup
  40.         <13>      7/7/95    RR        Some refactoring. Fix
  41.                                     CreatePropObjSpecifier to deal with
  42.                                     non-persistent frame. Set source frame of
  43.                                     dialogs.
  44.         <12>      7/3/95    RR        Added #if ODDebug around DebugStr
  45.         <11>     6/30/95    RR        1242642 BB Ref counting fixes. Display
  46.                                     settings window is saved as an ID, not a
  47.                                     window
  48.         <10>     6/29/95    VL        1242642: Release the created su in
  49.                                     CloneInto.
  50.          <9>     6/25/95    TÇ        1242642 BB: Turn on ODDebug warning if
  51.                                     refcount is wrong in
  52.                                     ODRefCntObjectsomUninit.
  53.          <8>     6/22/95    jpa        (oops, removed bogus in progress comment.)
  54.          <7>     6/22/95    jpa        Fixed refcounting of semantic interface.
  55.                                     [1261644]
  56.          <6>     6/20/95    JP        1251250: Acquire & Release extension
  57.                                     properly
  58.          <5>     6/13/95    JP        Recordable Clock
  59.          <4>      6/8/95    jpa        Use temp objects (TempODShape,
  60.                                     TempODFrame). [1246062]
  61.          <3>      6/8/95    RR        #1257260 Collapse base classes. #1214898
  62.                                     StdTypes.r -> ODTypes.r
  63.          <2>      6/3/95    TJ        Added #includes for compile with out PCH
  64.          <1>     5/31/95    RR        first checked in
  65.  
  66.     To Do:
  67.     In Progress:
  68.         
  69. */
  70.  
  71. #ifndef _ALTPOINT_
  72. #include "AltPoint.h"            // Use C++ savvy ODPoint and ODRect
  73. #endif
  74.  
  75. #ifndef _ODTYPES_
  76. #include <ODTypes.h>
  77. #endif
  78.  
  79. #ifndef SOM_ODRefCntObject_xh
  80. #include "RefCtObj.xh"
  81. #endif
  82.  
  83. #ifndef SOM_ODPart_xh
  84. #include "Part.xh"
  85. #endif
  86.  
  87. #ifndef _CLOCKFRM_
  88. #include "ClockFrm.h"
  89. #endif
  90.  
  91. #ifndef _CLOCKGBL_
  92. #include "ClockGbl.h"
  93. #endif
  94.  
  95. #ifndef _CLOCKPRT_
  96. #include "ClockPrt.h"
  97. #endif
  98.  
  99. #ifndef _CLOCKDEF_
  100. #include "ClockDef.h"
  101. #endif
  102.  
  103. #ifndef _PLFMDEF_
  104. #include "PlfmDef.h"
  105. #endif
  106.  
  107.  
  108. #ifndef _SIHELPER_
  109. #include "SIHelper.h"
  110. #endif
  111.  
  112. #ifndef SOM_Module_OpenDoc_Foci_defined
  113. #include <Foci.xh>
  114. #endif
  115.  
  116. #ifndef _USERSRCM_
  117. #include "UseRsrcM.h"
  118. #endif
  119.  
  120. #ifndef SOM_ODFocusSet_xh
  121. #include <FocusSet.xh>
  122. #endif
  123.  
  124. #ifndef SOM_Module_OpenDoc_StdProps_defined
  125. #include <StdProps.xh>
  126. #endif
  127.  
  128. #ifndef SOM_Module_OpenDoc_StdTypes_defined
  129. #include <StdTypes.xh>
  130. #endif
  131.  
  132.  
  133. #ifndef SOM_Module_OpenDoc_StdDefs_defined
  134. #include <StdDefs.xh>
  135. #endif
  136.  
  137. #ifndef SOM_ODDraft_xh
  138. #include <Draft.xh>
  139. #endif
  140.  
  141. #ifndef SOM_ODDocument_xh
  142. #include <Document.xh>
  143. #endif
  144.  
  145. #ifndef SOM_ODContainer_xh
  146. #include <ODCtr.xh>
  147. #endif
  148.  
  149. #ifndef SOM_ODStorageUnit_xh
  150. #include <StorageU.xh>
  151. #endif
  152.  
  153. #ifndef SOM_ODStorageUnitView_xh
  154. #include <SUView.xh>
  155. #endif
  156.  
  157. #ifndef SOM_ODStorageUnitCursor_xh
  158. #include <SUCursor.xh>
  159. #endif
  160.  
  161. #ifndef SOM_ODSession_xh
  162. #include <ODSessn.xh>
  163. #endif
  164.  
  165. #ifndef SOM_ODWindowState_xh
  166. #include <WinStat.xh>
  167. #endif
  168.  
  169. #ifndef SOM_ODFrame_xh
  170. #include <Frame.xh>
  171. #endif
  172.  
  173. #ifndef SOM_ODFacet_xh
  174. #include <Facet.xh>
  175. #endif
  176.  
  177. #ifndef SOM_ODFrameFacetIterator_xh
  178. #include <FrFaItr.xh>
  179. #endif
  180.  
  181. #ifndef _ORDCOLL_
  182. #include "OrdColl.h"
  183. #endif
  184.  
  185. #ifndef SOM_ODDispatcher_xh
  186. #include <Disptch.xh>
  187. #endif
  188.  
  189. #ifndef _ODUTILS_
  190. #include <ODUtils.h>
  191. #endif
  192.  
  193. #ifndef SOM_ODMenuBar_xh
  194. #include <MenuBar.xh>
  195. #endif
  196.  
  197. #ifndef SOM_Module_OpenDoc_Commands_defined
  198. #include <CmdDefs.xh>
  199. #endif
  200.  
  201. #ifndef _ITEXT_
  202. #include <IText.h>
  203. #endif
  204.  
  205. #ifndef _ISOSTRING_
  206. #include "ISOStr.h"
  207. #endif
  208.  
  209. #ifndef SOM_ODMessageInterface_xh
  210. #include <MssgIntf.xh>
  211. #endif
  212.  
  213. #ifndef _AEOBJECTS_
  214. #include "AEObjects.h"
  215. #endif
  216.  
  217. #ifndef _FOCUSLIB_
  218. #include "FocusLib.h"
  219. #endif
  220.  
  221. #ifndef SOM_ODArbitrator_xh
  222. #include <Arbitrat.xh>
  223. #endif
  224.  
  225. #ifndef SOM_ODWindow_xh
  226. #include <Window.xh>
  227. #endif
  228.  
  229. #ifndef SOM_ODShape_xh
  230. #include <Shape.xh>
  231. #endif
  232.  
  233. #ifndef SOM_ODTransform_xh
  234. #include <Trnsform.xh>
  235. #endif
  236.  
  237. #ifndef _EXCEPT_
  238. #include "Except.h"
  239. #endif
  240.  
  241. #ifndef __MENUS__
  242. #include <Menus.h>
  243. #endif
  244.  
  245. #ifndef __OSUTILS__
  246. #include <OSUtils.h>
  247. #endif
  248.  
  249. #ifndef __TOOLUTILS__
  250. #include <ToolUtils.h>
  251. #endif
  252.  
  253. #ifndef __FONTS__
  254. #include <Fonts.h>
  255. #endif
  256.  
  257. #ifndef __SCRIPT__
  258. #include <Script.h>
  259. #endif
  260.  
  261. #ifndef __TYPES__
  262. #include <Types.h>
  263. #endif
  264.  
  265. #ifndef __PACKAGES__
  266. #include <Packages.h>
  267. #endif
  268.  
  269. #ifndef __RESOURCES__
  270. #include <Resources.h>
  271. #endif
  272.  
  273. #ifndef __DIALOGS__
  274. #include "Dialogs.h"
  275. #endif
  276.  
  277. #ifndef __TEXTEDIT__
  278. #include <TextEdit.h>
  279. #endif
  280.  
  281. #ifndef __PACKAGES__
  282. #include <Packages.h>
  283. #endif
  284.  
  285. #ifndef __STRINGS__
  286. #include <Strings.h>
  287. #endif
  288.  
  289. #ifndef __FP__
  290. #include <Fp.h>
  291. #endif
  292.  
  293. #include <string.h>
  294.  
  295. #ifndef _ODDEBUG_
  296. #include "ODDebug.h"    
  297. #endif
  298.  
  299. #ifndef _STDTYPIO_
  300. #include "StdTypIO.h"
  301. #endif
  302.  
  303. #ifndef _INFOUTIL_
  304. #include <InfoUtil.h>
  305. #endif
  306.  
  307. #ifndef _WINUTILS_
  308. #include "WinUtils.h"
  309. #endif
  310.  
  311. #ifndef _ITEXT_
  312. #include <IText.h>
  313. #endif
  314.  
  315. #ifndef _PASCLSTR_
  316. #include "PasclStr.h"
  317. #endif
  318.  
  319. #ifndef _STORUTIL_
  320. #include <StorUtil.h>
  321. #endif
  322.  
  323. #ifndef _POUTILS_
  324. #include <POUtils.h>    // for UpdateModificationInfo
  325. #endif
  326.  
  327. #ifndef _CLOCKOBJ_
  328. #include "ClockObj.h"
  329. #endif
  330.  
  331. #ifndef SOM_ClockSI_xh
  332. #include "ClockSI.xh"
  333. #endif
  334.  
  335. #ifndef __AEPACKOBJECT__
  336. #include <AEPackObject.h>
  337. #endif
  338.  
  339. #ifndef SOM_Module_OpenDoc_ODRegistry_defined
  340. #include "ODRgstry.xh"
  341. #endif
  342.  
  343. #ifndef __ASREGISTRY__
  344. #include <ASRegistry.h>
  345. #endif
  346.  
  347. #ifndef _TEMPOBJ_
  348. #include <TempObj.h>
  349. #endif
  350.  
  351. #ifndef _SEUTILS_
  352. #include "SEUtils.h"
  353. #endif
  354.  
  355. #ifndef _ODDESUTL_
  356. #include <ODDesUtl.h>
  357. #endif
  358.  
  359. #ifndef SOM_ODAddressDesc_xh
  360. #include "ODAdrDes.xh"
  361. #endif
  362.  
  363. #ifndef SOM_ODAppleEvent_xh
  364. #include <ODAplEvt.xh>
  365. #endif
  366.  
  367. #define ODDebugLayers 0
  368.  
  369. //=========================================================================
  370. // Local Functions
  371. //=========================================================================
  372.  
  373. static ODFrame* AquirePersistantFrame(Environment* ev, ODFrame* frame);
  374.  
  375. //=========================================================================
  376. // ClockPart
  377. //=========================================================================
  378.  
  379. ClockPart::ClockPart()
  380. {
  381.     fContentFrames = kODNULL;                        // Create an empty collection for storing the list 
  382.                                                 // of frames to display    the "clock" in.    
  383.     
  384.     fFont   = GetSysFont();                    // Script Mgr: get the current system font
  385.     fSize   = GetDefFontSize();                // Script Mgr: get the current default font size
  386.     fStyle  = normal;                            // Font Mgr: enum for plain style
  387.  
  388.     fLastAscent = 0;                                // Ascent of the fFont font - used in positioning for drawing
  389.     
  390.     fFontMenu = kODNULL;
  391.     fSizeMenu = kODNULL;
  392.     fStyleMenu = kODNULL;
  393.     fViewMenu = kODNULL;
  394.     fExtraMenu = kODNULL;
  395.     fExtraSubMenu = kODNULL;
  396.     fMenuBar = kODNULL;
  397.     fSemanticInterface = kODNULL;
  398.     fTestClockSU = kODNULL;
  399.     fWorkPort = kODNULL;
  400.     
  401.     fAlarmEnabled = kODFalse;
  402.     fAnalog = kODFalse;
  403.     
  404.     fPartWrapper = kODNULL;
  405.     fSOMSelf = kODNULL;
  406.     
  407.     fModalFocus = kODNULL;
  408.     fFrameView = kODNULL;
  409.     fTimePresentation = kODNULL;
  410.     fSynchronizePresentation = kODNULL;
  411.     
  412.     fDirty = kODFalse;
  413. }
  414.  
  415. ClockPart::~ClockPart()
  416. {
  417.     Environment* ev = somGetGlobalEnvironment();
  418.  
  419.     ODDeleteObject(fContentFrames);// Release the display frames collection.
  420.                                     // Deletion of memory used by the object will be
  421.                                     // reclaimed when the shell deletes the
  422.                                     // instantiation.
  423.     if (fWorkPort)
  424.         DisposeWindow(fWorkPort);
  425.         //ODDisposePtr(fWorkPort);
  426.     
  427.     delete fSemanticInterface;        // Refcount must be zero by now.
  428. }
  429.  
  430. void ClockPart::InitClockPart(Environment* ev, 
  431.                                 ODSession* session,
  432.                                 ODPart* somSelf, 
  433.                                 ODPart* partWrapper)
  434. {
  435.     if (gClockGlobals)
  436.         gClockGlobals->AcquireGlobals(ev);
  437.     else
  438.     {
  439.         gClockGlobals = new ClockGlobals();
  440.         gClockGlobals->InitClockGlobals(ev, session, partWrapper);
  441.         gClockGlobals->AcquireGlobals(ev);
  442.     }
  443.  
  444.     fSOMSelf = somSelf;
  445.     fPartWrapper = partWrapper;
  446.     
  447.     fSession = session; //$$$$$ fSOMSelf->GetStorageUnit(ev)->GetSession(ev);                
  448.     
  449.     fArbitrator = fSession->GetArbitrator(ev);
  450.     fDispatcher = fSession->GetDispatcher(ev);
  451.     fWindowState = fSession->GetWindowState(ev);
  452.     
  453.     fSemanticInterface = new ClockSI;
  454.     SIHelper* semItfcHelper = new SIHelper;
  455.     semItfcHelper->InitSIHelper(fSession, fSemanticInterface);
  456.     fSemanticInterface->InitCPlusSemanticInterface(ev, somSelf, semItfcHelper, fSession);
  457.     InstallStaticCallbacks(semItfcHelper, this);
  458.  
  459.     Rect r;
  460.     SetRect(&r, 0,0,0,0);
  461.  
  462.     fWorkPort = NewCWindow(NULL, &r, "\p", kODFalse, documentProc, NULL, kODFalse, 0);
  463.     //fWorkPort = NewCWindow((Ptr)ODNewPtr(sizeof(WindowRecord)), &r, "\p", kODFalse, documentProc, NULL, kODFalse, 0);
  464.  
  465.     fModalFocus = fSession->Tokenize(ev, kODModalFocus);
  466.     fFrameView = fSession->Tokenize(ev, kODViewAsFrame);
  467.     fTimePresentation   = fSession->Tokenize(ev, kClockFrame);
  468.     fSynchronizePresentation  = fSession->Tokenize(ev, kSynchronizeFrame);
  469.     fAlarmSettingsPresentation   = fSession->Tokenize(ev, kAlarmSettingsFrame);
  470.     fDisplaySettingsPresentation   = fSession->Tokenize(ev, kDisplaySettingsFrame);
  471.     fDialogPresentation   = fSession->Tokenize(ev, kDialogFrame);
  472.     
  473.     fContentFrames = new OrderedCollection;        // Create an empty collection for storing the list 
  474.                                                 // of frames to display    the "clock" in.    
  475.  
  476.     ODSLong        savedRefNum;
  477.     BeginUsingLibraryResources(savedRefNum);
  478.  
  479.     fFontMenu = NewMenu(kClock_FontMenuID,"\pFont");
  480.     fSizeMenu = NewMenu(kClock_SizeMenuID,"\pSize");
  481.     fStyleMenu = GetMenu(kClock_StyleMenuID);
  482.     DetachResource((Handle) fStyleMenu);
  483.     fSettingsMenu = GetMenu(kClock_SettingsMenuID);
  484.     DetachResource((Handle) fSettingsMenu);
  485.     fViewMenu = GetMenu(kClock_ViewMenuID);
  486.     DetachResource((Handle) fViewMenu);
  487. #if ODDebug
  488.     if (!fFontMenu || !fSizeMenu || !fStyleMenu || !fSettingsMenu || !fViewMenu)
  489.         WARN("Error creating menus");
  490. #endif        
  491.     AppendResMenu( fFontMenu, 'FOND' );
  492.  
  493.     AppendMenu(fSizeMenu,"\p9");                // • • Move to resources for localization
  494.     AppendMenu(fSizeMenu,"\p10");
  495.     AppendMenu(fSizeMenu,"\p11");
  496.     AppendMenu(fSizeMenu,"\p12");
  497.     AppendMenu(fSizeMenu,"\p14");
  498.     AppendMenu(fSizeMenu,"\p18");
  499.     AppendMenu(fSizeMenu,"\p24");
  500.     AppendMenu(fSizeMenu,"\p36");
  501.  
  502.     EndUsingLibraryResources(savedRefNum);
  503.     this->BuildMenuBar(ev);
  504.  
  505. }
  506.  
  507. void ClockPart::PrepareStorage(Environment* ev, ODStorageUnit* storageUnit)
  508. {
  509.     storageUnit->AddProperty(ev, kODPropContents)->AddValue(ev, kODKindTestClock);    
  510.  
  511.     fTestClockSU = storageUnit->GetDraft(ev)->CreateStorageUnit(ev);
  512.  
  513.     fTestClockSU->AddProperty(ev,kPropClockType)->AddValue(ev, kODBoolean);    
  514.     fTestClockSU->AddProperty(ev,kPropClockFont)->AddValue(ev, kODUShort);    
  515.     fTestClockSU->AddProperty(ev,kPropClockStyle)->AddValue(ev, kODUShort);            
  516.     fTestClockSU->AddProperty(ev,kPropClockSize)->AddValue(ev, kODUShort);        
  517.     fTestClockSU->AddProperty(ev,kODPropDisplayFrames)->AddValue(ev, kODWeakStorageUnitRefs);
  518.     fDirty = kODTrue;
  519. }
  520.  
  521. void ClockPart::Release(Environment* ev)
  522. {
  523.     // SOM method has already called parent_Release()
  524.     
  525.     if ( fSOMSelf->GetRefCount(ev) == 0 )
  526.         fSOMSelf->GetStorageUnit(ev)->GetDraft(ev)->ReleasePart(ev, fPartWrapper);
  527. }
  528.  
  529. void ClockPart::ReleaseAll(Environment* ev)
  530. {
  531.     ODFinalReleaseObject(ev,fSemanticInterface);
  532.     ODReleaseObject(ev,fMenuBar);
  533.     ODReleaseObject(ev,fTestClockSU);
  534.  
  535.     if (gClockGlobals)
  536.         gClockGlobals->ReleaseGlobals(ev);
  537.  
  538.     OrderedCollectionIterator iter(fContentFrames);
  539.     
  540.     for (ODFrame* aFrame = (ODFrame*)iter.First(); 
  541.                             iter.IsNotComplete();
  542.                             aFrame = (ODFrame*)iter.Next())
  543.     {
  544.         ODReleaseObject(ev, aFrame);
  545.     }
  546. }
  547.  
  548. void ClockPart::Internalize(Environment* ev, ODStorageUnit* storageUnit)
  549. {
  550.     ODULong valueSize, offset;
  551.     ODStorageUnitRef aSURef;
  552.     ODFrame* aFrame;
  553.     ODStorageUnit* su;
  554.     
  555.     su = storageUnit; //$$$$$ somSelf->GetStorageUnit(ev);
  556.     su->Focus(ev, kODPropContents,kODPosSame,kODKindTestClock,1,kODPosFirstSib);
  557.     StorageUnitGetValue(su, ev, sizeof(ODStorageUnitRef),&aSURef);
  558.     if (su->IsValidStorageUnitRef(ev, aSURef))
  559.         fTestClockSU = su->GetDraft(ev)->AcquireStorageUnit(ev, su->GetIDFromStorageUnitRef(ev, aSURef));
  560.     else
  561.         WARN("No Clock SU");
  562.     su = fTestClockSU;
  563.     
  564.     su->Focus(ev, kPropClockType,kODPosSame,kODBoolean,1,kODPosFirstSib);
  565.     StorageUnitGetValue(su, ev, sizeof(ODBoolean), (ODValue)&fAnalog);
  566.     su->Focus(ev, kPropClockFont,kODPosSame,kODUShort,1,kODPosFirstSib);
  567.     StorageUnitGetValue(su, ev, sizeof(ODSShort), (ODValue)&fFont);
  568.     su->Focus(ev, kPropClockStyle,kODPosSame,kODUShort,1,kODPosFirstSib);
  569.     StorageUnitGetValue(su, ev, sizeof(ODSShort), (ODValue)&fStyle);
  570.     su->Focus(ev, kPropClockSize,kODPosSame,kODUShort,1,kODPosFirstSib);
  571.     StorageUnitGetValue(su, ev, sizeof(ODSShort), (ODValue)&fSize);
  572.     
  573.     //$$$$$ CloneInto does not currently externalize display frames
  574.     if ( su->Exists(ev,kODPropDisplayFrames, kODNULL, 0) )
  575.     {
  576.         su->Focus(ev, kODPropDisplayFrames,kODPosUndefined,0,1,kODPosFirstSib);
  577.         valueSize = su->GetSize(ev);
  578.         for (offset = 0; offset < valueSize; offset += sizeof(ODStorageUnitRef))
  579.         {
  580.             su->SetOffset(ev, offset);
  581.             StorageUnitGetValue(su, ev, sizeof(ODStorageUnitRef), (ODValue)&aSURef);
  582.             
  583.             if (su->IsValidStorageUnitRef(ev, aSURef)) {
  584.                 aFrame = su->GetDraft(ev)->AcquireFrame(ev, su->GetIDFromStorageUnitRef(ev, aSURef));
  585.                 this->AddContentFrame(ev, aFrame);
  586.                 aFrame->Release(ev); // Because both AddContentFrame and GetFrame increment
  587.             }
  588.             else 
  589.                 aFrame = kODNULL;
  590.         }
  591.     }
  592.     fDirty = kODFalse;
  593.     // We should minimize the frame shape here, but we can't because I think that
  594.     // the _fClockPart->fPart and _fClockPart->fPartInfo for the frame hasn't been set up yet.
  595.     // somSelf->AdjustFrameShape(ev, dispFrame);    
  596. }
  597.  
  598.  
  599. ODInfoType ClockPart::ReadPartInfo(Environment *ev,
  600.                                 ODFrame* frame, 
  601.                                 ODStorageUnitView*    storageUnitView)
  602. {
  603.     if (storageUnitView->GetSize(ev))
  604.     {
  605.         ClockTimeFrame* partInfo = new ClockTimeFrame();
  606.         partInfo->InitClockTimeFrame(ev, fSession, frame, this);
  607.         
  608.         /*
  609.         ODBoolean needsActivating;
  610.         StorageUnitGetValue(storageUnitView, ev, sizeof(ODBoolean),
  611.                                     (ODValue)&(needsActivating));
  612.         partInfo->fNeedsFoci = needsActivating;
  613.         */                                
  614.         return (ODInfoType)partInfo;
  615.     }
  616.     else
  617.         return ((ODInfoType)kODNULL);
  618. }
  619.  
  620. void ClockPart::Externalize(Environment *ev)
  621. {
  622.     ODFrame* aFrame;
  623.     ODStorageUnitRef aSURef;
  624.     ODULong offset, offsetLimit;
  625.     ODStorageUnit* su = fTestClockSU;
  626.  
  627.     if (fDirty)
  628.     {
  629.         su->Focus(ev, kPropClockType,kODPosSame,kODBoolean,1,kODPosFirstSib);
  630.         StorageUnitSetValue(su, ev, sizeof(ODBoolean), (ODValue)&fAnalog);
  631.         su->Focus(ev, kPropClockFont,kODPosSame,kODUShort,1,kODPosFirstSib);
  632.         StorageUnitSetValue(su, ev, sizeof(ODSShort), (ODValue)&fFont);
  633.         su->Focus(ev, kPropClockStyle,kODPosSame,kODUShort,1,kODPosFirstSib);
  634.         StorageUnitSetValue(su, ev, sizeof(ODSShort), (ODValue)&fStyle);
  635.         su->Focus(ev, kPropClockSize,kODPosSame,kODUShort,1,kODPosFirstSib);
  636.         StorageUnitSetValue(su, ev, sizeof(ODSShort), (ODValue)&fSize);
  637.         
  638.         OrderedCollectionIterator aIter(fContentFrames);
  639.         ODSUForceFocus(ev, su, kODPropDisplayFrames, kODWeakStorageUnitRefs);
  640.         //su->Focus(ev, kODPropDisplayFrames,kODPosUndefined,0,1,kODPosFirstSib);
  641.         offsetLimit = su->GetSize(ev);
  642.         offset = 0;
  643.         for (aFrame = (ODFrame*)aIter.First(); aIter.IsNotComplete();
  644.                                                 aFrame = (ODFrame*)aIter.Next(),
  645.                                                 offset+=sizeof(ODStorageUnitRef))
  646.         {
  647.             su->GetWeakStorageUnitRef(ev, aFrame->GetStorageUnit(ev)->GetID(ev), aSURef);
  648.             su->SetOffset(ev, offset);
  649.             StorageUnitSetValue(su, ev, sizeof(ODStorageUnitRef), aSURef);
  650.         }
  651.         if (offset < offsetLimit)
  652.             su->DeleteValue(ev, offsetLimit - offset);
  653.             
  654.         su = fSOMSelf->GetStorageUnit(ev);
  655.         su->Focus(ev, kODPropContents,kODPosSame,kODKindTestClock,1,kODPosFirstSib);
  656.         su->GetStrongStorageUnitRef(ev, fTestClockSU->GetID(ev), aSURef);
  657.         StorageUnitSetValue(su, ev, sizeof(ODStorageUnitRef),aSURef);
  658.         fDirty = kODFalse;
  659.     }
  660. }
  661.  
  662. void ClockPart::CloneInto(Environment *ev,
  663.                 ODDraftKey key,
  664.                 ODStorageUnit* storageUnit,
  665.                 ODFrame* scopeFrame)
  666. {
  667.     ODStorageUnitRef aSURef;
  668.  
  669.     ODStorageUnit* su = storageUnit->GetDraft(ev)->CreateStorageUnit(ev);
  670.     
  671.     //$$$$$$ ODSUForceFocus is not a public utility
  672.  
  673.     ODSUForceFocus(ev, su, kPropClockType, kODBoolean);
  674.     StorageUnitSetValue(su, ev, sizeof(ODBoolean), (ODValue)&fAnalog);
  675.     ODSUForceFocus(ev, su, kPropClockFont, kODUShort);
  676.     StorageUnitSetValue(su, ev, sizeof(ODSShort), (ODValue)&fFont);
  677.     ODSUForceFocus(ev, su, kPropClockStyle, kODUShort);
  678.     StorageUnitSetValue(su, ev, sizeof(ODSShort), (ODValue)&fStyle);
  679.     ODSUForceFocus(ev, su, kPropClockSize, kODUShort);
  680.     StorageUnitSetValue(su, ev, sizeof(ODSShort), (ODValue)&fSize);
  681.     
  682.     //$$$$$ Display Frames?
  683.     /*OrderedCollectionIterator aIter(fContentFrames);
  684.     su->Focus(ev, kODPropDisplayFrames,kODPosUndefined,0,1,kODPosFirstSib);
  685.     offsetLimit = su->GetSize(ev);
  686.     offset = 0;
  687.     for (aFrame = (ODFrame*)aIter.First(); aIter.IsNotComplete();
  688.                                             aFrame = (ODFrame*)aIter.Next(),
  689.                                             offset+=sizeof(ODStorageUnitRef))
  690.     {
  691.         su->GetWeakStorageUnitRef(ev, aFrame->GetStorageUnit(ev)->GetID(ev), aSURef);
  692.         su->SetOffset(ev, offset);
  693.         StorageUnitSetValue(su, ev, sizeof(ODStorageUnitRef), aSURef);
  694.     }
  695.     if (offset < offsetLimit)
  696.         su->DeleteValue(ev, offsetLimit - offset);
  697.     */    
  698.  
  699.     ODSUForceFocus(ev, storageUnit, kODPropContents, kODKindTestClock);
  700.     storageUnit->GetStrongStorageUnitRef(ev, su->GetID(ev), aSURef);
  701.     StorageUnitSetValue(storageUnit, ev, sizeof(ODStorageUnitRef),aSURef);
  702.     ODReleaseObject(ev, su);
  703. }
  704.  
  705. ODTypeToken ClockPart::CheckPresentation(Environment* ev, ODFrame* frame)
  706. {
  707.     ODTypeToken presentation = frame->GetPresentation(ev);
  708.     if ((presentation != fTimePresentation)
  709.         && (presentation != fSynchronizePresentation)
  710.         && (presentation != fAlarmSettingsPresentation)
  711.         && (presentation != fDisplaySettingsPresentation)
  712.         && (presentation != fDialogPresentation))
  713.     {
  714.         presentation = fTimePresentation;
  715.         frame->SetPresentation(ev, presentation);
  716.     }
  717.     return presentation;
  718. }
  719.  
  720. ClockFrame* ClockPart::CreateClockFrame(Environment* ev, ODFrame* frame, ODTypeToken presentation)
  721. {
  722.     ClockFrame* clockFrame = kODNULL;
  723.     if (presentation == fTimePresentation)
  724.     {
  725.         ClockTimeFrame* timeFrame = new ClockTimeFrame();
  726.         timeFrame->InitClockTimeFrame(ev, fSession, frame, this);
  727.         clockFrame = timeFrame;
  728.     }
  729.     else if (presentation == fSynchronizePresentation)
  730.     {
  731.         ClockSynchroDialogFrame* dialogFrame = new ClockSynchroDialogFrame();
  732.         dialogFrame->InitClockSynchroDialogFrame(ev, fSession, frame, this);
  733.         clockFrame = dialogFrame;
  734.     }
  735.     else if (presentation == fAlarmSettingsPresentation)
  736.     {
  737.         ClockAlarmSettingsDialogFrame* dialogFrame = new ClockAlarmSettingsDialogFrame();
  738.         dialogFrame->InitClockAlarmSettingsDialogFrame(ev, fSession, frame, this);
  739.         clockFrame = dialogFrame;
  740.     }
  741.     else if (presentation == fDisplaySettingsPresentation)
  742.     {
  743.         ClockDisplaySettingsDialogFrame* dialogFrame = new ClockDisplaySettingsDialogFrame();
  744.         dialogFrame->InitClockDisplaySettingsDialogFrame(ev, fSession, frame, this);
  745.         clockFrame = dialogFrame;
  746.         clockFrame->SetShouldDeleteWindow(kODFalse);
  747.     }
  748.     else if (presentation == fDialogPresentation)
  749.     {
  750.         ClockDialogFrame* dialogFrame = new ClockDialogFrame();
  751.         dialogFrame->InitClockDialogFrame(ev, fSession, frame, this);
  752.         clockFrame = dialogFrame;
  753.         clockFrame->SetShouldDeleteWindow(kODFalse);
  754.     }
  755.     return clockFrame;
  756. }
  757.  
  758.  
  759. void ClockPart::DisplayFrameAdded(Environment *ev,
  760.                                   ODFrame* frame)
  761. {
  762.     // We check for an existing ClockFrame in Part Info, because DisplayFrameAdded
  763.     // can get called multiple times, eg. when changing parts. 
  764.     // However DisplayFrameRemoved should probably delete the Part Info
  765.     
  766.     ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  767.     if (clockFrame == kODNULL)
  768.     {
  769.         ODTypeToken presentation = this->CheckPresentation(ev, frame);
  770.         clockFrame = this->CreateClockFrame(ev, frame, presentation);
  771.         frame->SetPartInfo(ev, (ODInfoType) clockFrame);            
  772.     }
  773.     if (clockFrame)
  774.     {
  775.         clockFrame->SetPart(ev, this);
  776.         clockFrame->Add(ev);
  777.     }
  778. }
  779.  
  780. void ClockPart::DisplayFrameConnected(Environment *ev,
  781.                                   ODFrame* frame)
  782. {
  783.     ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  784.     if (clockFrame == kODNULL)
  785.     {
  786.         ODTypeToken presentation = this->CheckPresentation(ev, frame);
  787.         clockFrame = this->CreateClockFrame(ev, frame, presentation);
  788.         frame->SetPartInfo(ev, (ODInfoType) clockFrame);            
  789.     }
  790.     if (clockFrame)
  791.     {
  792.         clockFrame->SetPart(ev, this);
  793.         clockFrame->Connect(ev);
  794.     }
  795. }
  796.  
  797. void ClockPart::DisplayFrameRemoved(Environment *ev,
  798.                                   ODFrame* frame)
  799. {
  800.     // We don't check _fClockPart->ContainsDisplayFrame because
  801.     // dialog frames are not added to the list
  802.     if ( this->ContainsDisplayFrame(ev, frame))
  803.     {
  804.     
  805.         ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  806.         clockFrame->Remove(ev);
  807.         frame->SetPartInfo(ev, (ODInfoType) kODNULL);
  808.         delete clockFrame;
  809.     }
  810.     else
  811.     {
  812.         ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  813.         clockFrame->Remove(ev);
  814.     }
  815.  
  816. }
  817.  
  818. void ClockPart::DisplayFrameClosed(Environment *ev,
  819.                                   ODFrame* frame)
  820. {
  821.     // We don't check _fClockPart->ContainsDisplayFrame because
  822.     // dialog frames are not added to the list
  823.     if ( this->ContainsDisplayFrame(ev, frame))
  824.     {    
  825.         ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  826.         
  827.         clockFrame->Close(ev);
  828.         frame->SetPartInfo(ev, (ODInfoType) kODNULL);
  829.         delete clockFrame;
  830.  
  831.     }
  832.     else
  833.     {
  834.         ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  835.         clockFrame->Close(ev);
  836.     }
  837. }
  838.  
  839. ODBoolean ClockPart::ContainsDisplayFrame(Environment* ev, ODFrame* frame)
  840. { 
  841.     if (fContentFrames)
  842.         return fContentFrames->Contains(frame);
  843.     else
  844.         return kODFalse;
  845. }
  846.     
  847. void ClockPart::AddContentFrame(Environment* ev, ODFrame* frame)
  848. {
  849.     if (fContentFrames)
  850.     {
  851.         if (!fContentFrames->Contains(frame))
  852.         {
  853.             fContentFrames->AddLast(frame);
  854.             frame->Acquire(ev);
  855.         }
  856.     }
  857. }
  858.  
  859. void ClockPart::RemoveContentFrame(Environment* ev, ODFrame* frame)
  860. {
  861.     if (fContentFrames && fContentFrames->Contains(frame))
  862.     {
  863.         fContentFrames->Remove(frame);
  864.         ODReleaseObject(ev, frame);
  865.     } else
  866.         WARN("Frame %p is not known to me",frame);
  867. }
  868.  
  869.  
  870. void ClockPart::AdjustDisplayFrames(Environment* ev)
  871. {
  872.     OrderedCollectionIterator iter(fContentFrames);
  873.     
  874.     for (ODFrame* aFrame = (ODFrame*)iter.First(); 
  875.                             iter.IsNotComplete();
  876.                             aFrame = (ODFrame*)iter.Next())
  877.     {
  878.         ClockFrame* clockFrame = (ClockFrame*) aFrame->GetPartInfo(ev);
  879.         clockFrame->Adjust(ev);
  880.     }
  881. }
  882.  
  883. void ClockPart::AdjustDialogs(Environment* ev)
  884. {
  885.     gClockGlobals->AdjustDialogs(ev);
  886. }
  887.  
  888. void ClockPart::BuildMenuBar(Environment* ev)
  889. {
  890.     if ((fMenuBar == kODNULL) || !(fMenuBar->IsValid(ev)))
  891.     {
  892.         fMenuBar = fWindowState->CopyBaseMenuBar(ev);
  893.         fMenuBar->AddMenuLast(ev, kClock_FontMenuID, fFontMenu, fPartWrapper);
  894.         fMenuBar->AddMenuLast(ev, kClock_SizeMenuID, fSizeMenu, fPartWrapper);
  895.         fMenuBar->AddMenuLast(ev, kClock_StyleMenuID,fStyleMenu, fPartWrapper);
  896.         fMenuBar->AddMenuLast(ev, kClock_SettingsMenuID, fSettingsMenu, fPartWrapper);
  897.         fMenuBar->AddMenuLast(ev, kClock_ViewMenuID, fViewMenu, fPartWrapper);
  898.  
  899.         fMenuBar->RegisterCommand(ev, cAnalog, kClock_ViewMenuID, 1);
  900.         fMenuBar->RegisterCommand(ev, cDigital, kClock_ViewMenuID, 2);
  901.         fMenuBar->RegisterCommand(ev, cNewView, kClock_ViewMenuID, 4);
  902.         fMenuBar->RegisterCommand(ev, cSynchronize, kClock_SettingsMenuID, 1);
  903.         fMenuBar->RegisterCommand(ev, cShowDisplaySettings, kClock_SettingsMenuID, 2);
  904.         fMenuBar->RegisterCommand(ev, cShowAlarmSettings, kClock_SettingsMenuID, 3);
  905.         fMenuBar->RegisterCommand(ev, cNewFloater, kClock_SettingsMenuID, 4);
  906.         fMenuBar->RegisterCommand(ev, cNewSinker, kClock_SettingsMenuID, 5);
  907.         fMenuBar->RegisterCommand(ev, cNewMenu, kClock_SettingsMenuID, 6);
  908.     }
  909. }
  910.  
  911. void ClockPart::InstallMenus(Environment* ev)
  912. {
  913.     this->BuildMenuBar(ev);    
  914.     
  915.     fMenuBar->Display(ev);
  916.  
  917.     this->OutlineSizeMenu(ev);
  918.     
  919.     Str255    tFontName;
  920.     
  921.     GetFontName(fFont, tFontName );
  922.     CheckMarkMenu(fFontMenu, tFontName, kODTrue );
  923.  
  924.     Str255    tSizeStr;
  925.     
  926.     NumToString( (ODULong)fSize, tSizeStr );
  927.     CheckMarkMenu(fSizeMenu, tSizeStr, kODTrue);
  928.     
  929.     Str255    tStyleStr;
  930.     
  931.     StyleToString(fStyle, (Str255 *)&tStyleStr);
  932.     CheckMarkMenu(fStyleMenu, tStyleStr, kODTrue );
  933. }
  934.  
  935.  
  936. void ClockPart::OutlineSizeMenu(Environment *ev)
  937. {
  938.     MenuHandle menu = GetMenuHandle( kClock_SizeMenuID );
  939.     
  940.     // (•) Outline the sizes in the font menu that are available
  941.     
  942.     if (RealFont(fFont, 9))
  943.         SetItemStyle( menu, kClock_Size_9Pt, outline );
  944.     else
  945.         SetItemStyle( menu, kClock_Size_9Pt, normal );
  946.  
  947.     if (RealFont(fFont, 10))
  948.         SetItemStyle( menu, kClock_Size_10Pt, outline );
  949.     else
  950.         SetItemStyle( menu, kClock_Size_10Pt, normal );
  951.  
  952.     if (RealFont(fFont, 11))
  953.         SetItemStyle( menu, kClock_Size_11Pt, outline );
  954.     else
  955.         SetItemStyle( menu, kClock_Size_11Pt, normal );
  956.  
  957.     if (RealFont(fFont, 12))
  958.         SetItemStyle( menu, kClock_Size_12Pt, outline );
  959.     else
  960.         SetItemStyle( menu, kClock_Size_12Pt, normal );
  961.  
  962.     if (RealFont(fFont, 14))
  963.         SetItemStyle( menu, kClock_Size_14Pt, outline );
  964.     else
  965.         SetItemStyle( menu, kClock_Size_14Pt, normal );
  966.  
  967.     if (RealFont(fFont, 18))
  968.         SetItemStyle( menu, kClock_Size_18Pt, outline );
  969.     else
  970.         SetItemStyle( menu, kClock_Size_18Pt, normal );
  971.  
  972.     if (RealFont(fFont, 24))
  973.         SetItemStyle( menu, kClock_Size_24Pt, outline );
  974.     else
  975.         SetItemStyle( menu, kClock_Size_24Pt, normal );
  976.  
  977.     if (RealFont(fFont, 36))
  978.         SetItemStyle( menu, kClock_Size_36Pt, outline );
  979.     else
  980.         SetItemStyle( menu, kClock_Size_36Pt, normal );
  981. }
  982.  
  983. void ClockPart::HandleFontMenu(Environment *ev, ODUShort item, ODFrame* frame)
  984. {
  985.     AEDesc        obj, font;
  986.     Str255        fontName;
  987.     ODError        err = noErr;
  988.  
  989.     ODPlatformMenu fontMenu = fMenuBar->GetMenu(ev,kClock_FontMenuID);
  990.     GetMenuItemText( fontMenu, item, fontName );
  991.     THROW_IF_ERROR( AECreateDesc(typeChar, &fontName[1], fontName[0], &font) );
  992.     this->CreatePropObjSpec(ev, pFont, obj);
  993.     TRY
  994.         this->SendSetDataEvent(ev, obj, font, frame);
  995.     CATCH_ALL
  996.         err = ErrorCode();
  997.     ENDTRY
  998.     AEDisposeDesc(&font);
  999.     AEDisposeDesc(&obj);
  1000.     THROW_IF_ERROR(err);
  1001. }
  1002.  
  1003. void ClockPart::ShowAboutBox(Environment* ev, ODFrame* frame)
  1004. {
  1005.     TempODFrame currentOwner = fArbitrator->AcquireFocusOwner(ev, fModalFocus);
  1006.     if (fArbitrator->RequestFocus(ev, fModalFocus,frame))
  1007.     {
  1008.         short itemHit;
  1009.         ParamText("\pClock Part…",0,0,0);
  1010.         SetCursor(&ODQDGlobals.arrow);
  1011.         ModalFilterUPP modalFilter = NewModalFilterProc(AboutDialogFilter);
  1012.         
  1013.         ODSLong        savedRefNum;
  1014.         BeginUsingLibraryResources(savedRefNum);
  1015.         DialogPtr aboutDialog = GetNewDialog(kClock_AboutBoxID ,0,(WindowPtr)-1L);
  1016.         EndUsingLibraryResources(savedRefNum);
  1017.  
  1018.         if (aboutDialog)
  1019.         {
  1020.             fWindowState->DeactivateFrontWindows(ev);    // Can be after GetNewDialog because
  1021.                                                         // Dialog is create invisible.
  1022.             ShowWindow(aboutDialog);
  1023.             do
  1024.             {
  1025.                 ModalDialog(modalFilter, &itemHit);
  1026.             } while (itemHit != 1);
  1027.             DisposeDialog(aboutDialog);
  1028.             fWindowState->ActivateFrontWindows(ev);
  1029.         }
  1030.         DisposeRoutineDescriptor(modalFilter);
  1031.  
  1032.         fArbitrator->TransferFocus(ev, fModalFocus,frame, currentOwner);        
  1033.     }
  1034.     else
  1035.         SysBeep(2);
  1036. }
  1037.  
  1038. void ClockPart::ShowSynchDialog(Environment* ev)
  1039. {
  1040.     ODSLong savedRefNum;
  1041.     BeginUsingLibraryResources(savedRefNum);
  1042.     
  1043.     DialogPtr synchDialog = GetNewDialog(kClock_SynchronizeDialogID ,(Ptr)ODNewPtr(sizeof(DialogRecord)),(WindowPtr)-1L);
  1044.         EndUsingLibraryResources(savedRefNum);
  1045.     ODWindow* synchWindow = fWindowState->
  1046.                                     RegisterWindow(ev, synchDialog,
  1047.                                         kODNonPersistentFrameObject,
  1048.                                          kODFalse,    // Keeps draft open
  1049.                                          kODFalse,    // Is resizable
  1050.                                          kODFalse,    // Is floating
  1051.                                          kODFalse, // don't save
  1052.                                          kODFalse,    // should dispose
  1053.                                          fPartWrapper, 
  1054.                                          fFrameView, 
  1055.                                          fSynchronizePresentation, 
  1056.                                          kODNULL);
  1057.     
  1058.     if (synchDialog 
  1059.         && (fArbitrator->RequestFocus(ev, fModalFocus,
  1060.                     synchWindow->GetRootFrame(ev))))
  1061.  
  1062.     {
  1063.         fMenuBar->DisableAll(ev);
  1064.         fMenuBar->EnableCommand(ev,  kODCommandEditMenu, kODTrue ) ;
  1065.         InvalMenuBar();
  1066.         
  1067.         SetCursor(&ODQDGlobals.arrow);
  1068.         synchWindow->Open(ev);
  1069.         synchWindow->Show(ev);
  1070.         synchWindow->Select(ev);
  1071.         ODReleaseObject(ev, synchWindow);
  1072.         
  1073.     }
  1074. }
  1075.  
  1076.  
  1077. void ClockPart::NewFloater(Environment* ev, ODFrame* frame)
  1078. {
  1079.     ODSLong savedRefNum;
  1080.     
  1081.     BeginUsingLibraryResources(savedRefNum);
  1082.     DialogPtr dialog = GetNewDialog(kClock_FloatingDialogID ,0,(WindowPtr)-1L);
  1083.     EndUsingLibraryResources(savedRefNum);
  1084.     
  1085.     ODWindow* window = fSOMSelf->GetStorageUnit(ev)->GetSession(ev)->GetWindowState(ev)->
  1086.                         RegisterWindow(ev, dialog, 
  1087.                             kODNonPersistentFrameObject,
  1088.                              kODFalse,    // Keeps draft open
  1089.                              kODFalse,    // Is resizable
  1090.                              kODTrue, // Is floating
  1091.                              kODFalse,    // don't save
  1092.                              kODTrue,    // should dispose
  1093.                              fPartWrapper,
  1094.                              fFrameView,
  1095.                              fDialogPresentation,
  1096.                              kODNULL);
  1097.  
  1098.     
  1099.     if (dialog && window)
  1100.     {
  1101.         window->Open(ev);
  1102.         window->Show(ev);
  1103.         window->Select(ev);
  1104.     }
  1105.  
  1106.     ODReleaseObject(ev, window);
  1107. }
  1108.  
  1109. void ClockPart::NewSinker(Environment* ev, ODFrame* frame)
  1110. {
  1111.     ODSLong savedRefNum;
  1112.     
  1113.     BeginUsingLibraryResources(savedRefNum);
  1114.     DialogPtr dialog = GetNewDialog(kClock_SinkingDialogID ,0,(WindowPtr)-1L);
  1115.     EndUsingLibraryResources(savedRefNum);
  1116.     
  1117.     ODWindow* window = fSOMSelf->GetStorageUnit(ev)->GetSession(ev)->GetWindowState(ev)->
  1118.                         RegisterWindow(ev, dialog, 
  1119.                                 kODNonPersistentFrameObject,
  1120.                                  kODFalse,    // Keeps draft open
  1121.                                  kODFalse,    // Is resizable
  1122.                                  kODFalse,    // Is floating
  1123.                                  kODFalse,    // don't save
  1124.                                  kODTrue,    // should dispose
  1125.                                  fPartWrapper,
  1126.                                  fFrameView,
  1127.                              fDialogPresentation,
  1128.                                  kODNULL);
  1129.  
  1130.         
  1131.     if (dialog && window)
  1132.     {
  1133.         window->Open(ev);
  1134.         window->Show(ev);
  1135.         window->Select(ev);
  1136.     }
  1137.  
  1138.     ODReleaseObject(ev, window);
  1139. }
  1140.  
  1141. void ClockPart::HandleSizeMenu(Environment *ev, ODUShort item, ODFrame* frame)
  1142. {
  1143.     AEDesc        obj, size;
  1144.     ODError        err = noErr;
  1145.     ODSShort    fontSize = 0;
  1146.  
  1147.     switch (item) 
  1148.     {
  1149.         case kClock_Size_9Pt:    fontSize =  9; break;
  1150.         case kClock_Size_10Pt:    fontSize = 10; break;
  1151.         case kClock_Size_11Pt:    fontSize = 11; break;
  1152.         case kClock_Size_12Pt:    fontSize = 12; break;
  1153.         case kClock_Size_14Pt:    fontSize = 14; break;
  1154.         case kClock_Size_18Pt:    fontSize = 18; break;
  1155.         case kClock_Size_24Pt:    fontSize = 24; break;
  1156.         case kClock_Size_36Pt:    fontSize = 36; break;
  1157.         default:
  1158.             fontSize = 12;
  1159.     }
  1160.     THROW_IF_ERROR( AECreateDesc(typeShortInteger, &fontSize, sizeof(fontSize), &size) );
  1161.     this->CreatePropObjSpec(ev, pPointSize, obj);
  1162.     TRY
  1163.         this->SendSetDataEvent(ev, obj, size, frame);
  1164.     CATCH_ALL
  1165.         err = ErrorCode();
  1166.     ENDTRY
  1167.     AEDisposeDesc(&size);
  1168.     AEDisposeDesc(&obj);
  1169.     THROW_IF_ERROR(err);
  1170. }
  1171.  
  1172. void ClockPart::HandleStyleMenu(Environment *ev, ODUShort item, ODFrame* frame)
  1173. {
  1174.     AEDesc        obj, style;
  1175.     DescType    fontStyle;
  1176.     ODError        err = noErr;
  1177.     
  1178.     switch (item) 
  1179.     {
  1180.         case kClock_Style_Plain:        fontStyle = kAEPlain; break;
  1181.         case kClock_Style_Bold:            fontStyle = kAEBold; break;
  1182.         case kClock_Style_Italic:        fontStyle = kAEItalic; break;
  1183.         case kClock_Style_Underline:    fontStyle = kAEUnderline; break;
  1184.         case kClock_Style_Outline:        fontStyle = kAEOutline; break;
  1185.         case kClock_Style_Shadow:        fontStyle = kAEShadow; break;
  1186.         case kClock_Style_Condense:        fontStyle = kAECondensed; break;
  1187.         case kClock_Style_Extend:        fontStyle = kAEExpanded; break;
  1188.         default:
  1189.             fontStyle = kAEPlain;
  1190.     }
  1191.     
  1192.     THROW_IF_ERROR( AECreateDesc(typeEnumerated, &fontStyle, sizeof(fontStyle), &style) );
  1193.     this->CreatePropObjSpec(ev, pTextStyles, obj);
  1194.     TRY
  1195.         this->SendSetDataEvent(ev, obj, style, frame);
  1196.     CATCH_ALL
  1197.         err = ErrorCode();
  1198.     ENDTRY
  1199.     AEDisposeDesc(&style);
  1200.     AEDisposeDesc(&obj);
  1201.     THROW_IF_ERROR(err);
  1202. }
  1203.  
  1204. void ClockPart::SendClockModeEvent(Environment *ev, ODBoolean analog, ODFrame* frame)
  1205. {
  1206.     AEDesc        obj, mode;
  1207.     DescType    clockMode;
  1208.     ODError        err = noErr;
  1209.     
  1210.     clockMode = kAEDigitalClock;
  1211.     if (analog)
  1212.         clockMode = kAEAnalogClock;
  1213.     THROW_IF_ERROR( AECreateDesc(typeEnumerated, &clockMode, sizeof(clockMode), &mode) );
  1214.     this->CreatePropObjSpec(ev, pDisplayMode, obj);
  1215.     TRY
  1216.         this->SendSetDataEvent(ev, obj, mode, frame);
  1217.     CATCH_ALL
  1218.         err = ErrorCode();
  1219.     ENDTRY
  1220.     AEDisposeDesc(&mode);
  1221.     AEDisposeDesc(&obj);
  1222.     THROW_IF_ERROR(err);
  1223. }
  1224.  
  1225.  
  1226. ODFrame* ClockPart::GetFirstFrame()
  1227. {
  1228.     WASSERT(fContentFrames != kODNULL);
  1229.     ODFrame* frame = (ODFrame*) fContentFrames->First();
  1230.     WASSERT(frame != kODNULL);
  1231.     return frame;
  1232. }
  1233.  
  1234. void ClockPart::SetAnalog(Environment* ev, ODBoolean analog)
  1235. {
  1236.     if (fAnalog != analog) 
  1237.     {
  1238.         fAnalog = analog;
  1239.         fDirty = kODTrue;
  1240.         fSOMSelf->GetStorageUnit(ev)->GetDraft(ev)->SetChangedFromPrev(ev);
  1241.     }
  1242. }
  1243.  
  1244. void ClockPart::SetFont(Environment *ev, ODSShort fontNum)
  1245. {
  1246.     if (fFont != fontNum) 
  1247.     {
  1248.         fFont = fontNum;
  1249.         fDirty = kODTrue;
  1250.         fSOMSelf->GetStorageUnit(ev)->GetDraft(ev)->SetChangedFromPrev(ev);
  1251.     }
  1252. }
  1253.  
  1254. void ClockPart::SetFontSize(Environment *ev, ODSShort fontSize)
  1255. {
  1256.     if (fSize != fontSize) 
  1257.     {
  1258.         fSize = fontSize;
  1259.         fDirty = kODTrue;
  1260.         fSOMSelf->GetStorageUnit(ev)->GetDraft(ev)->SetChangedFromPrev(ev);
  1261.     }
  1262. }
  1263.  
  1264. void ClockPart::SetFontStyle(Environment *ev, ODUByte fontStyle )
  1265. {
  1266.     if (fStyle != fontStyle) 
  1267.     {
  1268.         fStyle = fontStyle;
  1269.         fDirty = kODTrue;
  1270.         fSOMSelf->GetStorageUnit(ev)->GetDraft(ev)->SetChangedFromPrev(ev);
  1271.     }
  1272. }
  1273.  
  1274. ODWindow*  ClockPart::CreateWindow(Environment *ev, WindowProperties& props, ODFrame* rootFrame)
  1275. {
  1276.     ODWindow* window = kODNULL;
  1277.     ODPlatformWindow platformWindow = this->CreatePlatformWindow(props);
  1278.     if (rootFrame)
  1279.     {
  1280.         window =  fSession->GetWindowState(ev)->RegisterWindowForFrame(ev, 
  1281.                                                          platformWindow, 
  1282.                                                          rootFrame,
  1283.                                                          props.isRootWindow,    // Keeps draft open
  1284.                                                          props.isResizable,    // Is resizable
  1285.                                                          props.isFloating,    // Is floating
  1286.                                                          (props.sourceFrame == kODNULL),    // shouldSave
  1287.                                                          kODFalse,    // should dispose
  1288.                                                          props.sourceFrame);
  1289.     }
  1290.     else
  1291.     {    
  1292.         window =  fWindowState->
  1293.                     RegisterWindow(ev, platformWindow, 
  1294.                                 kODFrameObject,
  1295.                                 props.isRootWindow,            // is root
  1296.                                 props.isResizable,                // Is resizable
  1297.                                 props.isFloating,                // Is floating
  1298.                                 (props.sourceFrame == kODNULL),    // should save
  1299.                                 kODFalse,    // should dispose
  1300.                                 fPartWrapper, 
  1301.                                 fFrameView, 
  1302.                                 fTimePresentation, 
  1303.                                 props.sourceFrame);
  1304.     }
  1305.     return window;
  1306. }
  1307.  
  1308. ODBoolean ClockPart::HandleOSEvent(Environment* ev, ODEventData* event, ODFrame* frame, ODFacet* facet)
  1309. {
  1310.     const short     kSuspendResumeMessage = 0x01;    // Resume vs. suspend mask
  1311.     unsigned char     typeOSEvent;
  1312.     
  1313.     // • Is it a multifinder event?
  1314.     typeOSEvent = (unsigned char) (event->message >> 24) & 0x00FF;
  1315.     
  1316.     // • Switch on the type of OSEvent that occurred, high byte of message is event type
  1317.     switch (typeOSEvent) 
  1318.     {                     
  1319.         case kSuspendResumeMessage:
  1320.             {
  1321.                 ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  1322.                 const short kResumeMask = 0x01;    // High byte suspend/resume event 
  1323.                 ODBoolean    goingToBackground = (event->message & kResumeMask) == 0;
  1324.                 
  1325.                 if (goingToBackground)
  1326.                 {
  1327. #if defined(ODDebug) && ODDebugLayers
  1328.     somPrintf("Clock Going to Background. Frame: %x Facet: %x\n", frame, facet);
  1329. #endif
  1330.                     clockFrame->SuspendProcess(ev);    
  1331.                 }
  1332.                 else
  1333.                 {
  1334. #if defined(ODDebug) && ODDebugLayers
  1335.     somPrintf("Clock Coming to Foreground. Frame: %x Facet: %x\n", frame, facet);
  1336. #endif
  1337.                     clockFrame->ResumeProcess(ev);    
  1338.                     
  1339.                 }
  1340.             }
  1341.         default:
  1342.             break;
  1343.     }
  1344.     return kODTrue;
  1345. }
  1346.  
  1347. ODID ClockPart::OpenInitialWindow(Environment *ev)
  1348. {
  1349.     ODWindow* window = kODNULL;
  1350.     WindowProperties props;
  1351.     this->GetDefaultWindowProperties(ev, &props, kODNULL);
  1352.  
  1353.     window = this->CreateWindow(ev, props, kODNULL);
  1354.     ODID windowID = window->GetID(ev);
  1355.     window->Open(ev);
  1356.     window->Show(ev);
  1357.     window->Select(ev);    
  1358.     ODReleaseObject(ev, window);    
  1359.     return windowID;            
  1360. }
  1361.  
  1362. void ClockPart::GetDefaultWindowProperties(Environment* ev, WindowProperties* props, ODFrame* sourceFrame)
  1363. {
  1364.     CopyPascalString(props->title, "\pClock");
  1365.     props->procID = zoomDocProc;
  1366.     props->hasCloseBox = kODTrue;
  1367.     props->refCon = 0;
  1368.     props->wasVisible = kODTrue;
  1369.     props->isResizable = kODTrue;
  1370.     props->isFloating = kODFalse;
  1371.     props->isRootWindow = (sourceFrame == kODNULL);
  1372.     props->shouldShowLinks = kODFalse;
  1373.     props->sourceFrame = sourceFrame;
  1374.  
  1375.     this->CalcClockBounds(props->boundsRect);
  1376.     if (!fAnalog)
  1377.     {
  1378.         props->boundsRect.right += 15;
  1379.         props->boundsRect.bottom += 15;
  1380.     }
  1381.     OffsetRect(&props->boundsRect, 40, 40);
  1382.  
  1383.     ODName* windowName = kODNULL;
  1384.     if (sourceFrame)
  1385.         windowName = ODGetPartName(ev, sourceFrame, kODNULL);
  1386.     if (windowName==kODNULL || GetITextStringLength(windowName)==0)
  1387.         CopyPascalString(props->title, "\pClock");
  1388.     else
  1389.         GetITextPString(windowName, props->title);
  1390.     if (windowName)
  1391.         DisposeIText(windowName);
  1392. }
  1393.  
  1394. ODPlatformWindow ClockPart::CreatePlatformWindow(WindowProperties& props)
  1395. {
  1396.     ODPlatformWindow platformWindow = NewCWindow((Ptr)ODNewPtr(sizeof(WindowRecord)), 
  1397.                                                     &(props.boundsRect), 
  1398.                                                     props.title, 
  1399.                                                     kODFalse /*visible */, 
  1400.                                                     props.procID, 
  1401.                                                     (WindowPtr)-1L, 
  1402.                                                     props.hasCloseBox, 
  1403.                                                     props.refCon);
  1404.     return platformWindow;
  1405. }
  1406.  
  1407. ODID ClockPart::OpenRootFrame(Environment *ev, ODFrame* frame)
  1408. {
  1409.     ODWindow* window = kODNULL;
  1410.     ODID windowID = 0;
  1411.     WindowProperties props;
  1412.     
  1413.     ODBoolean hasWindowProperties = BeginGetWindowProperties(ev, frame, &props);
  1414.     if (!hasWindowProperties)
  1415.         this->GetDefaultWindowProperties(ev, &props, kODNULL);
  1416.     ODPlatformWindow platformWindow = this->CreatePlatformWindow(props);
  1417.     ClockFrame* clockFrame = (ClockFrame*) frame->GetPartInfo(ev);
  1418.     // Set the platform window early, so that if RegisterWindow fails, clockFrame
  1419.     // can still get to the platform window to dispose of it.
  1420.     if (clockFrame)
  1421.         clockFrame->SetPlatformWindow(platformWindow); 
  1422.     TRY{
  1423.         window =  fSession->GetWindowState(ev)->RegisterWindowForFrame(ev, platformWindow, 
  1424.                                                         frame,
  1425.                                                          props.isRootWindow,    // Keeps draft open
  1426.                                                          kODTrue,    // Is resizable
  1427.                                                          kODFalse,    // Is floating
  1428.                                                          kODTrue,    // shouldSave
  1429.                                                          kODFalse,    // should dispose
  1430.                                                          props.sourceFrame);
  1431.     }CATCH_ALL{
  1432.         TRY{
  1433.             EndGetWindowProperties(ev, &props); // Release source frame
  1434.         }CATCH_ALL{
  1435.             //ignore errors
  1436.         }ENDTRY
  1437.         RERAISE;
  1438.     }ENDTRY
  1439.     EndGetWindowProperties(ev, &props); // Release source frame
  1440.     window->Open(ev);
  1441.     window->Show(ev);
  1442.     windowID = window->GetID(ev);
  1443.     ODReleaseObject(ev, window);
  1444.     return windowID;
  1445. }
  1446.  
  1447.  
  1448. void  ClockPart::AdjustMenus(Environment *ev)
  1449. {
  1450.     //fMenuBar->EnableCommand(ev, kODCommandViewAsWin, !frame->IsRoot(ev));
  1451.     fMenuBar->EnableAndCheckCommand(ev, cAnalog , kODTrue, fAnalog);
  1452.     fMenuBar->EnableAndCheckCommand(ev, cDigital , kODTrue, !fAnalog);
  1453.  
  1454.     Str255        fontName;
  1455.     ODPlatformMenu fontMenu = fMenuBar->GetMenu(ev,kClock_FontMenuID);
  1456.     GetFontName(fFont, fontName );
  1457.     CheckMarkMenu(fontMenu, fontName, kODTrue );
  1458.  
  1459.     ODIText*    menuItem;
  1460.     // DON'T DO THIS! FOR LOCALISABILITY, READ THE TEXT OUT OF A RESOURCE AND
  1461.     //    USE THE CURRENT SYSTEM SCRIPT AND CURRENT SYSTEM LANGUAGE.
  1462.     menuItem = CreateIText(smRoman, langEnglish, "About Clock…");
  1463.     fMenuBar->SetItemString(ev, kODCommandAbout, menuItem);
  1464.     DisposeIText(menuItem);
  1465.     
  1466. }
  1467.  
  1468. //------------------------------------------------------------------------------
  1469. // ClockPart: HandleMenuEvent
  1470. //------------------------------------------------------------------------------
  1471.  
  1472.  
  1473. ODBoolean ClockPart::HandleMenuEvent(Environment *ev, ODEventData* event, ODFrame* frame)
  1474. {
  1475.     ODBoolean wasHandled = kODTrue;
  1476.  
  1477.     long menuResult = event->message;
  1478.     short menu = HiWord(menuResult);
  1479.     short item = LoWord(menuResult);
  1480.     ODCommandID command = fMenuBar->GetCommand(ev, menu, item);
  1481.  
  1482.     if (fMenuBar->IsCommandSynthetic(ev, command))    // Font, Size, Style
  1483.     {
  1484.         switch ( menu ) 
  1485.         {
  1486.             case kClock_FontMenuID:    
  1487.                 this->HandleFontMenu(ev, item, frame ); 
  1488.                 break;
  1489.             case kClock_SizeMenuID:    
  1490.                 this->HandleSizeMenu(ev,  item, frame ); 
  1491.                 break;
  1492.             case kClock_StyleMenuID:    
  1493.                 this->HandleStyleMenu(ev, item, frame );
  1494.                 break;
  1495.             default:
  1496.                 wasHandled = kODFalse;
  1497.                 break;
  1498.         }
  1499.         
  1500.     }
  1501.     else
  1502.     {
  1503.         switch (command)
  1504.         {
  1505.             case kODCommandAbout:
  1506.                 this->ShowAboutBox(ev, frame);
  1507.                 break;
  1508.             case cAnalog:
  1509.                 this->SendClockModeEvent(ev, kODTrue, frame);
  1510.                 break;
  1511.             case cDigital:
  1512.                 this->SendClockModeEvent(ev, kODFalse, frame);
  1513.                 break;
  1514.             case cSynchronize:
  1515.                 this->ShowSynchDialog(ev);
  1516.                 break;
  1517.             case cShowAlarmSettings:
  1518.                 gClockGlobals->OpenAlarmSettingsDialog(ev, frame);
  1519.                 break;
  1520.             case cShowDisplaySettings:
  1521.                 gClockGlobals->OpenDisplaySettingsDialog(ev, frame);
  1522.                 this->AdjustDialogs(ev);
  1523.                 break;
  1524.             case cNewFloater:
  1525.                 this->NewFloater(ev, frame);
  1526.                 break;
  1527.             case cNewSinker:
  1528.                 this->NewSinker(ev, frame);
  1529.                 break;
  1530.             case cNewMenu:
  1531.                 {
  1532.                     if (fExtraMenu == kODNULL)
  1533.                     {
  1534.                         fExtraMenu = NewMenu(kClock_ExtraMenuID, "\pMenu");
  1535.                         AppendMenu(fExtraMenu, "\pDelete Me");
  1536.                         fMenuBar->AddMenuBefore(ev, kClock_ExtraMenuID, fExtraMenu, fPartWrapper, kClock_FontMenuID);
  1537.                         fMenuBar->RegisterCommand(ev, cDeleteMenu, kClock_ExtraMenuID, 1);
  1538.                     }
  1539.                     else if (fExtraSubMenu == kODNULL)
  1540.                     {
  1541.                         fExtraSubMenu = NewMenu(kClock_ExtraSubMenuID, "\pSubMenu");
  1542.                         AppendMenu(fExtraSubMenu, "\pSubItem");
  1543.                         AppendMenu(fExtraMenu, "\pHier");
  1544.                         fMenuBar->AddSubMenu(ev, kClock_ExtraSubMenuID, fExtraSubMenu, fPartWrapper);
  1545.                         SetItemCmd(fExtraMenu,2, hMenuCmd);
  1546.                         SetItemMark(fExtraMenu,2, kClock_ExtraSubMenuID);
  1547.                     }
  1548.                     else
  1549.                         SysBeep(2);
  1550.  
  1551.                 }
  1552.                 break;
  1553.             case cDeleteMenu:
  1554.                 {
  1555.                     fMenuBar->UnregisterCommand(ev, cDeleteMenu);
  1556.                     fMenuBar->RemoveMenu(ev, kClock_ExtraMenuID);
  1557.                     fMenuBar->RemoveMenu(ev, kClock_ExtraSubMenuID);
  1558.                     if (fExtraMenu)
  1559.                     {
  1560.                         DisposeMenu(fExtraMenu);
  1561.                         fExtraMenu = kODNULL;
  1562.                     }
  1563.                     if (fExtraSubMenu)
  1564.                     {
  1565.                         DisposeMenu(fExtraSubMenu);
  1566.                         fExtraSubMenu = kODNULL;
  1567.                     }
  1568.                     
  1569.                 }
  1570.                 break;
  1571.             default:
  1572.                 wasHandled = kODFalse;
  1573.                 break;
  1574.         }
  1575.     }
  1576.     return wasHandled;
  1577. }
  1578.  
  1579. ODBoolean ClockPart::CloseWindow(Environment* ev, ODFrame* frame)
  1580. {
  1581.     ODBoolean         handled            = kODFalse;
  1582.     ODTypeToken presentation = frame->GetPresentation(ev);
  1583.     
  1584.     if (presentation == fDisplaySettingsPresentation)
  1585.     {
  1586.         gClockGlobals->CloseDisplaySettingsWindow(ev);
  1587.         handled = kODTrue;
  1588.     }
  1589.     else if (presentation == fAlarmSettingsPresentation)
  1590.     {
  1591.         gClockGlobals->CloseAlarmSettingsWindow(ev);
  1592.         handled = kODTrue;
  1593.     }
  1594.         
  1595.     return handled;
  1596. }
  1597.  
  1598.  
  1599. ODShape* ClockPart::CreateOvalShape(Environment* ev, ODFrame* frame, Rect& rect)
  1600. {
  1601.     GrafPtr savedPort;
  1602.     GetPort(&savedPort);
  1603.     SetPort(fWorkPort);
  1604.     RgnHandle region = ODNewRgn();
  1605.     OpenRgn();
  1606.     FrameOval(&rect);
  1607.     CloseRgn(region);
  1608.     
  1609.     ODShape* newShape = frame->CreateShape(ev);
  1610.     newShape->SetQDRegion(ev, region);
  1611.     SetPort(savedPort);
  1612.     return newShape;
  1613. }
  1614.  
  1615.  
  1616. ClockSI*    ClockPart::AquireSI(Environment* ev)
  1617. {
  1618.     fSemanticInterface->Acquire(ev);
  1619.     return fSemanticInterface;
  1620. }
  1621.  
  1622.  
  1623. #ifndef ff
  1624. #define ff(N)        ( (ODCoordinate)(N) <<16 )    // Converts integer to fixed (ODCoordinate)
  1625. #endif
  1626.  
  1627. void ClockPart::CalcClockBounds(Rect& rect)
  1628. {
  1629.     if (fAnalog)
  1630.         SetRect(&rect, 0,0,150,150);
  1631.     else
  1632.     {
  1633.         GrafPtr savedPort;
  1634.         GetPort(&savedPort);
  1635.         SetPort(fWorkPort);
  1636.         
  1637.         TextFont(fFont);
  1638.         TextFace(fStyle );
  1639.         TextMode(srcCopy );
  1640.         TextSize(fSize );
  1641.     
  1642.         FontInfo fontIRec;
  1643.         GetFontInfo( &fontIRec );
  1644.         fLastAscent = fontIRec.ascent;
  1645.         
  1646.                                         // • • move to resource for localization
  1647.         //rect.Set(0, 0, ff(StringWidth("\p12:59:59 MM")+4),
  1648.         //              ff((fontIRec.ascent+fontIRec.descent+fontIRec.leading)+2) );
  1649.         SetRect(&rect, 0, 0, StringWidth("\p12:59:59 MM")+4,
  1650.                       (fontIRec.ascent+fontIRec.descent+fontIRec.leading)+2 );
  1651.         SetPort(savedPort);
  1652.     }
  1653. }    // ClockPart::CalcClockBounds
  1654.  
  1655.  
  1656. void ClockPart::CreatePropObjSpec(Environment* ev, DescType prop, AEDesc& objSpec)
  1657. {
  1658.     AEDesc                    nullDesc = NULL_DESCRIPTOR_DEFINITION;
  1659.     AEDesc                    pr = NULL_DESCRIPTOR_DEFINITION;
  1660.     DescType                activePart;
  1661.  
  1662.     // create "prop of active part" reference
  1663.     activePart = pActivePart;
  1664.     TRY
  1665.         // active part
  1666.         THROW_IF_ERROR( AECreateDesc(typeType, (Ptr) &activePart, sizeof(activePart), &pr) );
  1667.         THROW_IF_ERROR( CreateObjSpecifier(cProperty, &nullDesc, formPropertyID, &pr, kODTrue, &objSpec) );
  1668.         // prop of active part
  1669.         THROW_IF_ERROR( AECreateDesc(typeType, (Ptr) &prop, sizeof(prop), &pr) );
  1670.         THROW_IF_ERROR( CreateObjSpecifier(cProperty, &objSpec, formPropertyID, &pr, kODTrue, &objSpec) );
  1671.     CATCH_ALL
  1672.         AEDisposeDesc(&pr);
  1673.         RERAISE;
  1674.     ENDTRY
  1675. }    // ClockPart::CreatePropObjSpec
  1676.  
  1677.  
  1678. void ClockPart::SendSetDataEvent(Environment* ev, AEDesc& objSpec, AEDesc& data, ODFrame* frame)
  1679. {
  1680.     ODAddressDesc*        address = kODNULL;
  1681.     ODAppleEvent*        event = kODNULL;
  1682.     ODAppleEvent*        reply = kODNULL;
  1683.     AEDesc                aeevent = NULL_DESCRIPTOR_DEFINITION;
  1684.     ODMessageInterface*    mess = kODNULL;
  1685.     ODError                err = noErr;
  1686.     TempODFrame            activeFrame = AquirePersistantFrame(ev, frame);
  1687.     TempODPart            part = activeFrame->AcquirePart(ev);
  1688.     AEDesc                nullDesc = NULL_DESCRIPTOR_DEFINITION;
  1689.     AEDesc                subject = NULL_DESCRIPTOR_DEFINITION;
  1690.     AEDesc                pr = NULL_DESCRIPTOR_DEFINITION;
  1691.     DescType            activePart;
  1692.  
  1693.     ODVolatile(address);
  1694.     ODVolatile(event);
  1695.     ODVolatile(reply);
  1696.  
  1697.     TRY
  1698.         // get the message interface
  1699.         mess = fSOMSelf->GetStorageUnit(ev)->GetSession(ev)->GetMessageInterface(ev);
  1700.         // create an event
  1701.         mess->CreatePartAddrDesc(ev, &address, fSOMSelf);
  1702.         mess->CreateEvent(ev, kAECoreSuite, kAESetData, address, kAnyTransactionID, &event);
  1703.         ODDescToAEDesc(event, &aeevent);
  1704.         // add direct parameter and data parameter
  1705.         THROW_IF_ERROR( AEPutParamDesc(&aeevent, keyDirectObject, &objSpec) );
  1706.         THROW_IF_ERROR( AEPutParamDesc(&aeevent, keyAEData, &data) );
  1707.         // add the active part subject attribute
  1708.         activePart = pActivePart;
  1709.         THROW_IF_ERROR( AECreateDesc(typeType, (Ptr) &activePart, sizeof(activePart), &pr) );
  1710.         THROW_IF_ERROR( CreateObjSpecifier(cProperty, &nullDesc, formPropertyID, &pr, kODTrue, &subject) );
  1711.         THROW_IF_ERROR( AEPutAttributeDesc(&aeevent, keySubjectAttr, &subject) );
  1712.         AEDescToODDesc(&aeevent, event);
  1713.         // create the reply
  1714.         reply = new ODAppleEvent;
  1715.         THROW_IF_NULL(reply);
  1716.         reply->InitODAppleEvent(ev);
  1717.         // send the event with a null frame so no part id subject is added (which would stomp ours)
  1718.         mess->Send(ev, kODNULL, part, event, reply, kAENoReply, kAENormalPriority, kAEDefaultTimeout);
  1719.     CATCH_ALL
  1720.         err = ErrorCode();
  1721.     ENDTRY
  1722.     AEDisposeDesc(&aeevent);
  1723.     AEDisposeDesc(&subject);
  1724. //    AEDisposeDesc(&pr);        // this one should already be disposed by CreateObjectSpecifier
  1725.     ODDeleteObject(address);
  1726.     ODDeleteObject(event);
  1727.     ODDeleteObject(reply);
  1728.     THROW_IF_ERROR(err);
  1729. }
  1730.  
  1731. ODFrame* AquirePersistantFrame(Environment* ev, ODFrame* frame)
  1732. {
  1733.     // Temporary hack to use activeFrame, otherwise we fail when a dialog is up,
  1734.     // because its frame is nonpersistent
  1735.     // A better approach might be to add delegation of menu commands from
  1736.     // dialog frames to the source frame of the dialog window.
  1737.     //TempODFrame activeFrame = fArbitrator->AcquireFocusOwner(ev, fSession->Tokenize(ev, kODSelectionFocus));
  1738.     
  1739.     ODFrame* activeFrame = kODNULL;
  1740.     if (frame->GetStorageUnit(ev) == kODNULL)
  1741.     {
  1742.         TempODWindow window = frame->AcquireWindow(ev);
  1743.         activeFrame = window->AcquireSourceFrame(ev);
  1744.     }
  1745.     else
  1746.     {
  1747.         activeFrame = frame;
  1748.         activeFrame->Acquire(ev);
  1749.     }
  1750.     return activeFrame;
  1751. }
  1752.  
  1753.